package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsCycle;
import com.wicket.okrcomponent.integration.dto.ImplementTimeAddAndSubComRespDto;
import com.wicket.okrcomponent.integration.dto.ImplementTimeAddAndSubComReqDto;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbDashboardWorkTask;
import com.wicket.okrapp.biz.service.CycleTypeService;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrframework.integration.dto.QueryDirectInductionRecordListComRespDto;
import com.wicket.okrframework.integration.dto.QueryDirectInductionRecordListComReqDto;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrframework.integration.FwBaseInductionRecordClient;
import com.wicket.okrapp.biz.service.DashboardTargetContentService;
import com.wicket.okrapp.base.service.dto.common.VirtualOrgMemberDto;
import com.wicket.okrapp.base.service.MOmsQuestionService;
import com.wicket.okrapp.dal.po.mbg.OmsQuestion;
import com.wicket.okrapp.base.service.dto.req.BatchQueryQuestionSolvesRankReq;
import com.wicket.okrapp.biz.service.dto.common.QuestionDto;
import java.util.ArrayList;
import com.wicket.okrapp.biz.service.SmallCircleCommonService;
import com.wicket.okrapp.base.service.dto.req.BatchQueryQuestionTimeoutRankReq;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.dal.po.mbg.OmsTask;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTaskProgressRankReq;
import com.wicket.okrapp.biz.service.dto.common.TaskDataDto;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTaskExpiedRankReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTaskReq;
import com.wicket.okrapp.biz.service.dto.common.WorkContentDto;
import com.wicket.okrapp.base.service.dto.req.QueryCycleByEqualGreateAndLessGreateListReq;
import com.wicket.okrapp.biz.service.dto.common.CycleDto;
import com.wicket.okrcomponent.integration.dto.QueryWorkTaskCycleConfDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.QueryWorkTaskCycleConfDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.CheckTimeScopeSearchComRespDto;
import com.wicket.okrcomponent.integration.dto.CheckTimeScopeSearchComReqDto;
import com.wicket.okrcomponent.integration.FwCompDashboardWorkTaskClient;
import com.wicket.okrcomponent.integration.FwCompDivineDataClient;
import com.wicket.okrapp.base.service.dto.req.QueryTaskExpiedRankListReq;
import com.wicket.okrapp.biz.service.dto.common.WorkTaskDto;
import com.wicket.okrapp.base.service.dto.req.QueryTaskProgressRankListComReq;
import com.wicket.okrapp.base.service.dto.req.QueryQuestionTimeoutRankListReq;
import com.wicket.okrapp.base.service.dto.req.QueryQuestionSolvesRankListReq;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.base.service.dto.req.QueryTimeRangeFindCycleDetailReq;
import com.wicket.okrapp.base.service.dto.req.QueryCycleByTimeEqualDetailReq;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrapp.base.service.dto.req.QueryTimeStatisticsTasksListComReq;
import com.wicket.okrapp.base.service.dto.req.BatchQueryTimeStatisticsTasksReq;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class DashboardWorkTaskServiceImpl
  implements com.wicket.okrapp.biz.service.DashboardWorkTaskService {

  @Resource
  private RedisUtil redisUtil;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
@Resource
  private MOmsCycleService mOmsCycleService;
@Resource
  private NbDashboardWorkTask nbDashboardWorkTask;
@Resource
  private CycleTypeService cycleTypeService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwBaseInductionRecordClient fwBaseInductionRecordClient;
@Resource
  private DashboardTargetContentService dashboardTargetContentService;
@Resource
  private MOmsQuestionService mOmsQuestionService;
@Resource
  private SmallCircleCommonService smallCircleCommonService;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private FwCompDashboardWorkTaskClient fwCompDashboardWorkTaskClient;
@Resource
  private FwCompDivineDataClient fwCompDivineDataClient;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
/**
   * D3分析工作归属与更新周期及上一周期(公共)[8894]
   * gen by moon at 7/22/2024, 10:11:03 PM
   */
  @Trace(operationName = "D3分析工作归属与更新周期及上一周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisWorkBelongAndUpdatePreviousCycleComRespDto analysisWorkBelongAndUpdatePreviousCycleCom(AnalysisWorkBelongAndUpdatePreviousCycleComReqDto reqDto){
    
      
      ImplementEightReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定系统当前时间  65402
      //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1663946_1_65402
  
    /*M3约定系统当前时间[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComTimeField(),"D3分析工作归属与更新周期及上一周期(公共)-M3约定系统当前时间-通用时间字段不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);
      
      
      
//virtualUsage D3分析租户周期(公共)  65420
      AnalysisTenementCycleComRespDto analysisTenementCycleComRespDto = null;
    AnalysisTenementCycleComReqDto analysisTenementCycleComReqDto=new AnalysisTenementCycleComReqDto();
  if(reqDto!=null){
      analysisTenementCycleComReqDto.setIsTenementCycle(reqDto.getIsTenementCycle());//SimpleFieldAssign//sourceId:1664709_1_65420
analysisTenementCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1664740_1_65420
    }
  
    /*D3分析租户周期(公共)[8903]   */
    Assert.isNull(analysisTenementCycleComReqDto.getIsTenementCycle(),"D3分析工作归属与更新周期及上一周期(公共)-D3分析租户周期(公共)-是否租户周期不能为空",false);
Assert.isNull(analysisTenementCycleComReqDto.getSpaceId(),"D3分析工作归属与更新周期及上一周期(公共)-D3分析租户周期(公共)-创建于空间ID不能为空",false);
      analysisTenementCycleComRespDto = cycleTypeService.analysisTenementCycleCom(analysisTenementCycleComReqDto)/*vcase invoke isSameApp*/;
      
      
      
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71865
      OmsCycle omsCycle = null;
    if(analysisTenementCycleComRespDto !=null){
          QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq=new QueryTimeRangeFindCycleDetailReq();
  if(receptionServiceRes!=null){
      queryTimeRangeFindCycleDetailReq.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948282_1_71865
queryTimeRangeFindCycleDetailReq.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948283_1_71865
    }
if(reqDto!=null){
      queryTimeRangeFindCycleDetailReq.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1948284_1_71865
    }
if(analysisTenementCycleComRespDto!=null){
      queryTimeRangeFindCycleDetailReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948285_1_71865
queryTimeRangeFindCycleDetailReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1948294_1_71865
    }
  
    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
      omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71866
      OmsCycle omsCycle_2 = null;
    if(analysisTenementCycleComRespDto !=null){
          QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_1=new QueryTimeRangeFindCycleDetailReq();
  if(receptionServiceRes!=null){
      queryTimeRangeFindCycleDetailReq_1.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948282_1_71866
queryTimeRangeFindCycleDetailReq_1.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1948283_1_71866
    }
if(reqDto!=null){
      queryTimeRangeFindCycleDetailReq_1.setCycleTypeCode(reqDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1948284_1_71866
queryTimeRangeFindCycleDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1948294_1_71866
    }
if(analysisTenementCycleComRespDto!=null){
      queryTimeRangeFindCycleDetailReq_1.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948285_1_71866
    }
  
    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleStartTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleEndTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleTypeCode(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getPlatformData(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
      omsCycle_2 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
//virtualUsage D2更新周期开始时间减1秒（用于查上一周期ID）  65405
      ImplementTimeAddAndSubComRespDto implementTimeAddAndSubComRespDto = null;
    if(omsCycle !=null){
          ImplementTimeAddAndSubComReqDto implementTimeAddAndSubComReqDto=new ImplementTimeAddAndSubComReqDto();
  implementTimeAddAndSubComReqDto.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1664067_1_65405
implementTimeAddAndSubComReqDto.setCalcFormula("SUBTRACTION_OF_TWO_NUM");//sourceId:1664065_1_65405
implementTimeAddAndSubComReqDto.setTimeUnitType("SECOND");//sourceId:1664066_1_65405
if(omsCycle!=null){
      implementTimeAddAndSubComReqDto.setComTimeField(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1664064_1_65405
    }
  
    /*D2更新周期开始时间减1秒（用于查上一周期ID）[7369]   */
    Assert.isNull(implementTimeAddAndSubComReqDto.getComTimeField(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用时间字段不能为空",false);
Assert.isNull(implementTimeAddAndSubComReqDto.getComNumField(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用数值字段（整数型）不能为空",false);
Assert.isNull(implementTimeAddAndSubComReqDto.getCalcFormula(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用计算公式不能为空",false);
Assert.isNull(implementTimeAddAndSubComReqDto.getTimeUnitType(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-时间单位类型不能为空",false);
      implementTimeAddAndSubComRespDto = fwCompInterfaceModeClient.implementTimeAddAndSubCom(implementTimeAddAndSubComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      
           }
//virtualUsage D2更新周期开始时间减1秒（用于查上一周期ID）  68474
      ImplementTimeAddAndSubComRespDto implementTimeAddAndSubComRespDto_2 = null;
    if(omsCycle_2 !=null){
          ImplementTimeAddAndSubComReqDto implementTimeAddAndSubComReqDto_1=new ImplementTimeAddAndSubComReqDto();
  implementTimeAddAndSubComReqDto_1.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1664067_1_68474
implementTimeAddAndSubComReqDto_1.setCalcFormula("SUBTRACTION_OF_TWO_NUM");//sourceId:1664065_1_68474
implementTimeAddAndSubComReqDto_1.setTimeUnitType("SECOND");//sourceId:1664066_1_68474
if(omsCycle_2!=null){
      implementTimeAddAndSubComReqDto_1.setComTimeField(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1664064_1_68474
    }

    /*D2更新周期开始时间减1秒（用于查上一周期ID）[7369]   */
    Assert.isNull(implementTimeAddAndSubComReqDto_1.getComTimeField(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用时间字段不能为空",false);
Assert.isNull(implementTimeAddAndSubComReqDto_1.getComNumField(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用数值字段（整数型）不能为空",false);
Assert.isNull(implementTimeAddAndSubComReqDto_1.getCalcFormula(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-通用计算公式不能为空",false);
Assert.isNull(implementTimeAddAndSubComReqDto_1.getTimeUnitType(),"D3分析工作归属与更新周期及上一周期(公共)-D2更新周期开始时间减1秒（用于查上一周期ID）-时间单位类型不能为空",false);
      implementTimeAddAndSubComRespDto_2 = fwCompInterfaceModeClient.implementTimeAddAndSubCom(implementTimeAddAndSubComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71867
      OmsCycle omsCycle_3 = null;
    if(implementTimeAddAndSubComRespDto !=null&&analysisTenementCycleComRespDto !=null){
          QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_2=new QueryTimeRangeFindCycleDetailReq();
if(implementTimeAddAndSubComRespDto!=null){
      queryTimeRangeFindCycleDetailReq_2.setCycleStartTime(implementTimeAddAndSubComRespDto.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948295_1_71867
queryTimeRangeFindCycleDetailReq_2.setCycleEndTime(implementTimeAddAndSubComRespDto.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948296_1_71867
    }
if(reqDto!=null){
      queryTimeRangeFindCycleDetailReq_2.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1948297_1_71867
    }
if(analysisTenementCycleComRespDto!=null){
      queryTimeRangeFindCycleDetailReq_2.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948298_1_71867
queryTimeRangeFindCycleDetailReq_2.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1948307_1_71867
    }
  
    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getCycleStartTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getCycleEndTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getCycleTypeCode(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_2.getPlatformData(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
      omsCycle_3 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  71868
      OmsCycle omsCycle_5 = null;
    if(implementTimeAddAndSubComRespDto_2 !=null&&analysisTenementCycleComRespDto !=null){
          QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_3=new QueryTimeRangeFindCycleDetailReq();
if(implementTimeAddAndSubComRespDto_2!=null){
      queryTimeRangeFindCycleDetailReq_3.setCycleStartTime(implementTimeAddAndSubComRespDto_2.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948295_1_71868
queryTimeRangeFindCycleDetailReq_3.setCycleEndTime(implementTimeAddAndSubComRespDto_2.getCalcTimeResult());//SimpleFieldAssign//sourceId:1948296_1_71868
    }
if(reqDto!=null){
      queryTimeRangeFindCycleDetailReq_3.setCycleTypeCode(reqDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1948297_1_71868
    }
if(analysisTenementCycleComRespDto!=null){
      queryTimeRangeFindCycleDetailReq_3.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1948298_1_71868
queryTimeRangeFindCycleDetailReq_3.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1948307_1_71868
    }

    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getCycleStartTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getCycleEndTime(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getCycleTypeCode(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_3.getPlatformData(),"D3分析工作归属与更新周期及上一周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
      omsCycle_5 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage M3接收工作归属、更新及上一周期出参  65410
      //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsCycle_3 !=null&&omsCycle_5 !=null&&omsCycle_2 !=null&&omsCycle !=null){
          ImplementEightReceivingFieldReqDto receptionServiceReq_1=new ImplementEightReceivingFieldReqDto();
  if(omsCycle_3!=null){
      receptionServiceReq_1.setPreUpdateCycleId(omsCycle_3.getCycleId());//SimpleFieldAssign//sourceId:1801877_1_65410
    }
if(omsCycle_5!=null){
      receptionServiceReq_1.setPreviousCycleId(omsCycle_5.getCycleId());//SimpleFieldAssign//sourceId:1664059_1_65410
    }
if(omsCycle_2!=null){
      receptionServiceReq_1.setCycleId(omsCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1664061_1_65410
receptionServiceReq_1.setCycleStartTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1664120_1_65410
receptionServiceReq_1.setCycleEndTime(omsCycle_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1664121_1_65410
receptionServiceReq_1.setCycleTypeCode(omsCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1664122_1_65410
receptionServiceReq_1.setCycleTypeInstanceCode(omsCycle_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1664123_1_65410
    }
if(omsCycle!=null){
      receptionServiceReq_1.setUpdateCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1664060_1_65410
receptionServiceReq_1.setUpdateCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1664124_1_65410
receptionServiceReq_1.setUpdateCycleEndTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1664125_1_65410
receptionServiceReq_1.setUpdateCycleTypeCode(omsCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1664126_1_65410
    }
  
    /*M3接收工作归属、更新及上一周期出参[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleId(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-归属周期ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getCycleStartTime(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getCycleEndTime(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-周期结束时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getCycleTypeCode(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-周期类型标识不能为空",false);
Assert.isNull(receptionServiceReq_1.getUpdateCycleId(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getUpdateCycleStartTime(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getUpdateCycleEndTime(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期结束时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getUpdateCycleTypeCode(),"D3分析工作归属与更新周期及上一周期(公共)-M3接收工作归属、更新及上一周期出参-更新周期类型标识不能为空",false);
      receptionServiceRes_2 = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq_1);
      
      
      receptionServiceRes_3 = receptionServiceRes_2;
           }
AnalysisWorkBelongAndUpdatePreviousCycleComRespDto retData = new AnalysisWorkBelongAndUpdatePreviousCycleComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setPreUpdateCycleId(receptionServiceRes_3.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1801885_1
      retData.setPreviousCycleId(receptionServiceRes_3.getPreviousCycleId());//SimpleFieldAssign//sourceId:1664171_1
retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1664172_1
retData.setCycleStartTime(receptionServiceRes_3.getCycleStartTime());//SimpleFieldAssign//sourceId:1664173_1
retData.setCycleEndTime(receptionServiceRes_3.getCycleEndTime());//SimpleFieldAssign//sourceId:1664174_1
retData.setCycleTypeCode(receptionServiceRes_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:1664175_1
retData.setCycleTypeInstanceCode(receptionServiceRes_3.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1664176_1
retData.setUpdateCycleId(receptionServiceRes_3.getUpdateCycleId());//SimpleFieldAssign//sourceId:1664177_1
retData.setUpdateCycleStartTime(receptionServiceRes_3.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1664178_1
retData.setUpdateCycleEndTime(receptionServiceRes_3.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1664179_1
retData.setUpdateCycleTypeCode(receptionServiceRes_3.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1664180_1
    }
  

  
  
return retData;
  }
/**
   * D3查询部门下人员工作小圈子列表(公共)[8991]
   * gen by moon at 4/2/2024, 6:21:52 PM
   */
  @Trace(operationName = "D3查询部门下人员工作小圈子列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListCom(QueryDeptSubPersonnelSmallCircleListComReqDto reqDto){


      BatchQueryVirtualOrgMemberByinducRecIdComRespDto batchQueryVirtualOrgMemberByinducRecIdComRespDto_1 =null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1679597_1
receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1680056_1
receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685207_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1685233_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679600_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDeptId(),"D3查询部门下人员工作小圈子列表(公共)-M3接收入参字段-部门ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseScene(),"D3查询部门下人员工作小圈子列表(公共)-M3接收入参字段-虚拟组织使用场景不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询部门下人员工作小圈子列表(公共)-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D1-3查直属就职记录列表(公共) - queryDirectInductionRecordListCom
     QueryDirectInductionRecordListComRespDto queryDirectInductionRecordListComRespDto = null;
    QueryDirectInductionRecordListComReqDto queryDirectInductionRecordListComReqDto=new QueryDirectInductionRecordListComReqDto();
  queryDirectInductionRecordListComReqDto.setIsTransaction("FALSE");//sourceId:1679585_1
queryDirectInductionRecordListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1679586_1
if(reqDto!=null){
      queryDirectInductionRecordListComReqDto.setEntityId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1679580_1
queryDirectInductionRecordListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679588_1
    }

    /*D1-3查直属就职记录列表(公共)[8057]   */
    Assert.isNull(queryDirectInductionRecordListComReqDto.getEntityId(),"D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-就职单位对象实例ID不能为空",false);
Assert.isNull(queryDirectInductionRecordListComReqDto.getIsTransaction(),"D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-是否异动不能为空",false);
Assert.isNull(queryDirectInductionRecordListComReqDto.getSubjectLifeCycle(),"D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryDirectInductionRecordListComReqDto.getSpaceId(),"D3查询部门下人员工作小圈子列表(公共)-D1-3查直属就职记录列表(公共)-创建于空间ID不能为空",false);
      queryDirectInductionRecordListComRespDto = fwBaseInductionRecordClient.queryDirectInductionRecordListCom(queryDirectInductionRecordListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D3批量查询人员小圈子By就职记录(公共) - batchQueryVirtualOrgMemberByinducRecIdCom
     BatchQueryVirtualOrgMemberByinducRecIdComRespDto batchQueryVirtualOrgMemberByinducRecIdComRespDto = null;
    if(queryDirectInductionRecordListComRespDto !=null){
          BatchQueryVirtualOrgMemberByinducRecIdComReqDto batchQueryVirtualOrgMemberByinducRecIdComReqDto=new BatchQueryVirtualOrgMemberByinducRecIdComReqDto();
  batchQueryVirtualOrgMemberByinducRecIdComReqDto.setIsPersonCharge("TRUE");//sourceId:1679612_1
batchQueryVirtualOrgMemberByinducRecIdComReqDto.setIsDisplay("TRUE");//sourceId:1679611_1
if(queryDirectInductionRecordListComRespDto!= null&&  queryDirectInductionRecordListComRespDto.getOrgInductionRecordList() !=null&& !CollectionUtil.isEmpty(queryDirectInductionRecordListComRespDto.getOrgInductionRecordList())){
      batchQueryVirtualOrgMemberByinducRecIdComReqDto.setVirtualOrgMemberList(queryDirectInductionRecordListComRespDto.getOrgInductionRecordList().stream().map(item->item.getInductionRecordId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1679605_1
    }
if(reqDto!=null){
      batchQueryVirtualOrgMemberByinducRecIdComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1679607_1
batchQueryVirtualOrgMemberByinducRecIdComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1679610_1
batchQueryVirtualOrgMemberByinducRecIdComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1685232_1
batchQueryVirtualOrgMemberByinducRecIdComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679608_1
    }

    /*D3批量查询人员小圈子By就职记录(公共)[8872]   */
    Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getUseScene(),"D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getIsPersonCharge(),"D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-是否负责人不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getIsDisplay(),"D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-是否外部展示不能为空",false);
Assert.isNull(batchQueryVirtualOrgMemberByinducRecIdComReqDto.getSpaceId(),"D3查询部门下人员工作小圈子列表(公共)-D3批量查询人员小圈子By就职记录(公共)-创建于空间ID不能为空",false);
      batchQueryVirtualOrgMemberByinducRecIdComRespDto = dashboardTargetContentService.batchQueryVirtualOrgMemberByinducRecIdCom(batchQueryVirtualOrgMemberByinducRecIdComReqDto)/*vcase invoke isSameApp*/;


      batchQueryVirtualOrgMemberByinducRecIdComRespDto_1 = batchQueryVirtualOrgMemberByinducRecIdComRespDto;
           }

QueryDeptSubPersonnelSmallCircleListComRespDto retData = new QueryDeptSubPersonnelSmallCircleListComRespDto();
  if(batchQueryVirtualOrgMemberByinducRecIdComRespDto_1!=null){
      retData.setVirtualOrgMemberList(batchQueryVirtualOrgMemberByinducRecIdComRespDto_1.getVirtualOrgMemberList().stream().map(item -> BeanUtil.toBean(item, VirtualOrgMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1680060_1
    }




return retData;
  }
/**
   * D3查询个人问题解决时长排行列表[9009]
   * gen by moon at 4/1/2024, 1:57:08 AM
   */
  @Trace(operationName = "D3查询个人问题解决时长排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPersonalQuestionSolveRankListRespDto queryPersonalQuestionSolveRankList(QueryPersonalQuestionSolveRankListReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681435_1
receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681444_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681434_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(),"D3查询个人问题解决时长排行列表-M3接收入参字段-身份人员ID不能为空",false);
Assert.isNull(receptionServiceReq.getQuestionStatus(),"D3查询个人问题解决时长排行列表-M3接收入参字段-问题状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询个人问题解决时长排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1681428_1
queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1681429_1
queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1681430_1
queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1681431_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681432_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681427_1
queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681433_1
    }

    /*D3查入参身份人员负责的问题列表[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-是否负责人不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-虚拟组织使用场景不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-是否外部展示不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询个人问题解决时长排行列表-D3查入参身份人员负责的问题列表-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-7-02批量查询问题解决天数排行 - batchQueryQuestionSolvesRank
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryQuestionSolvesRankReq batchQueryQuestionSolvesRankReq=new BatchQueryQuestionSolvesRankReq();
  batchQueryQuestionSolvesRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681440_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryQuestionSolvesRankReq.setQuestionList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681438_1
    }
if(reqDto!=null){
      batchQueryQuestionSolvesRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681439_1
batchQueryQuestionSolvesRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681441_1
    }

    /*3-7-02批量查询问题解决天数排行[9004]   */
    Assert.isNull(batchQueryQuestionSolvesRankReq.getQuestionStatus(),"D3查询个人问题解决时长排行列表-3-7-02批量查询问题解决天数排行-问题状态不能为空",false);
Assert.isNull(batchQueryQuestionSolvesRankReq.getSubjectLifeCycle(),"D3查询个人问题解决时长排行列表-3-7-02批量查询问题解决天数排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryQuestionSolvesRankReq.getSpaceId(),"D3查询个人问题解决时长排行列表-3-7-02批量查询问题解决天数排行-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.batchQueryQuestionSolvesRank(batchQueryQuestionSolvesRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;
           }

QueryPersonalQuestionSolveRankListRespDto retData = new QueryPersonalQuestionSolveRankListRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681446_1




return retData;
  }
/**
   * D3查询个人问题超时排行列表[9010]
   * gen by moon at 4/1/2024, 1:57:21 AM
   */
  @Trace(operationName = "D3查询个人问题超时排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPersonalQuestionTimeoutRankListRespDto queryPersonalQuestionTimeoutRankList(QueryPersonalQuestionTimeoutRankListReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681480_1
receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681482_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681481_1
    }

    /*M3接收字段入参[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(),"D3查询个人问题超时排行列表-M3接收字段入参-身份人员ID不能为空",false);
Assert.isNull(receptionServiceReq.getQuestionStatus(),"D3查询个人问题超时排行列表-M3接收字段入参-问题状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询个人问题超时排行列表-M3接收字段入参-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1681469_1
queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1681470_1
queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1681471_1
queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1681472_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681473_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681468_1
queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681474_1
    }

    /*D3查入参身份人员负责的问题列表[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-是否负责人不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-虚拟组织使用场景不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-是否外部展示不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询个人问题超时排行列表-D3查入参身份人员负责的问题列表-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-7-02批量查询问题超时排行 - batchQueryQuestionTimeoutRank
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryQuestionTimeoutRankReq batchQueryQuestionTimeoutRankReq=new BatchQueryQuestionTimeoutRankReq();
  batchQueryQuestionTimeoutRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681477_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryQuestionTimeoutRankReq.setQuestionList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681475_1
    }
if(reqDto!=null){
      batchQueryQuestionTimeoutRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1681476_1
batchQueryQuestionTimeoutRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681478_1
    }

    /*3-7-02批量查询问题超时排行[9006]   */
    Assert.isNull(batchQueryQuestionTimeoutRankReq.getQuestionStatus(),"D3查询个人问题超时排行列表-3-7-02批量查询问题超时排行-问题状态不能为空",false);
Assert.isNull(batchQueryQuestionTimeoutRankReq.getSubjectLifeCycle(),"D3查询个人问题超时排行列表-3-7-02批量查询问题超时排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryQuestionTimeoutRankReq.getSpaceId(),"D3查询个人问题超时排行列表-3-7-02批量查询问题超时排行-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.batchQueryQuestionTimeoutRank(batchQueryQuestionTimeoutRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;
           }

QueryPersonalQuestionTimeoutRankListRespDto retData = new QueryPersonalQuestionTimeoutRankListRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681491_1




return retData;
  }
/**
   * D3查询部门任务进度排行图表列表[9011]
   * gen by moon at 4/2/2024, 6:21:54 PM
   */
  @Trace(operationName = "D3查询部门任务进度排行图表列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryDeptTaskProgressRankingChartListRespDto queryDeptTaskProgressRankingChartList(QueryDeptTaskProgressRankingChartListReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1681891_1
receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1681892_1
receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685266_1
receptionServiceReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1681889_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681881_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDeptId(),"D3查询部门任务进度排行图表列表-M3接收入参字段-部门ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseScene(),"D3查询部门任务进度排行图表列表-M3接收入参字段-虚拟组织使用场景不能为空",false);
Assert.isNull(receptionServiceReq.getTableTypeCode(),"D3查询部门任务进度排行图表列表-M3接收入参字段-冗余内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTaskStatus(),"D3查询部门任务进度排行图表列表-M3接收入参字段-任务进展状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询部门任务进度排行图表列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
     QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
    QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto=new QueryDeptSubPersonnelSmallCircleListComReqDto();
  if(reqDto!=null){
      queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1681722_1
queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1681725_1
queryDeptSubPersonnelSmallCircleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685209_1
queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681723_1
    }

    /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
    Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(),"D3查询部门任务进度排行图表列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(),"D3查询部门任务进度排行图表列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(),"D3查询部门任务进度排行图表列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空",false);
      queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤2: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    if(queryDeptSubPersonnelSmallCircleListComRespDto !=null){
          BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq=new BatchQueryTaskProgressRankReq();
  batchQueryTaskProgressRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681728_1
if(queryDeptSubPersonnelSmallCircleListComRespDto!= null&&  queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryTaskProgressRankReq.setTaskDataList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681731_1
    }
if(reqDto!=null){
      batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1681727_1
batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681729_1
    }

    /*3-7-01批量查询任务进度排行[8999]   */
    Assert.isNull(batchQueryTaskProgressRankReq.getTaskStatus(),"D3查询部门任务进度排行图表列表-3-7-01批量查询任务进度排行-任务进展状态不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(),"D3查询部门任务进度排行图表列表-3-7-01批量查询任务进度排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(),"D3查询部门任务进度排行图表列表-3-7-01批量查询任务进度排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }

QueryDeptTaskProgressRankingChartListRespDto retData = new QueryDeptTaskProgressRankingChartListRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681904_1




return retData;
  }
/**
   * D3查询部门任务逾期排行列表[9012]
   * gen by moon at 4/2/2024, 6:21:56 PM
   */
  @Trace(operationName = "D3查询部门任务逾期排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryDeptTaskExpiedRankingListRespDto queryDeptTaskExpiedRankingList(QueryDeptTaskExpiedRankingListReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682089_1
receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682090_1
receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685278_1
receptionServiceReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1682094_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682092_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDeptId(),"D3查询部门任务逾期排行列表-M3接收入参字段-部门ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseScene(),"D3查询部门任务逾期排行列表-M3接收入参字段-虚拟组织使用场景不能为空",false);
Assert.isNull(receptionServiceReq.getTableTypeCode(),"D3查询部门任务逾期排行列表-M3接收入参字段-冗余内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getStateCode(),"D3查询部门任务逾期排行列表-M3接收入参字段-内容冗余状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询部门任务逾期排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
     QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
    QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto=new QueryDeptSubPersonnelSmallCircleListComReqDto();
  if(reqDto!=null){
      queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682079_1
queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682082_1
queryDeptSubPersonnelSmallCircleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685210_1
queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682080_1
    }

    /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
    Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(),"D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(),"D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getTableTypeCode(),"D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(),"D3查询部门任务逾期排行列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空",false);
      queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤2: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    if(queryDeptSubPersonnelSmallCircleListComRespDto !=null){
          BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq=new BatchQueryTaskExpiedRankReq();
  batchQueryTaskExpiedRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682087_1
if(queryDeptSubPersonnelSmallCircleListComRespDto!= null&&  queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryTaskExpiedRankReq.setTaskDataList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682084_1
    }
if(reqDto!=null){
      batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1682086_1
batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682088_1
    }

    /*3-7-01批量查询任务逾期排行[9002]   */
    Assert.isNull(batchQueryTaskExpiedRankReq.getStateCode(),"D3查询部门任务逾期排行列表-3-7-01批量查询任务逾期排行-内容冗余状态不能为空",false);
Assert.isNull(batchQueryTaskExpiedRankReq.getSubjectLifeCycle(),"D3查询部门任务逾期排行列表-3-7-01批量查询任务逾期排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(),"D3查询部门任务逾期排行列表-3-7-01批量查询任务逾期排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }

QueryDeptTaskExpiedRankingListRespDto retData = new QueryDeptTaskExpiedRankingListRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682100_1




return retData;
  }
/**
   * D3查询部门问题解决天数排行图表列表[9013]
   * gen by moon at 4/2/2024, 11:50:56 PM
   */
  @Trace(operationName = "D3查询部门问题解决天数排行图表列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryDeptQuestionSolvesRankingChartListRespDto queryDeptQuestionSolvesRankingChartList(QueryDeptQuestionSolvesRankingChartListReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682512_1
receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682527_1
receptionServiceReq.setOwnTableTypeCode(reqDto.getOwnTableTypeCode());//SimpleFieldAssign//sourceId:1682529_1
receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682552_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682528_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDeptId(),"D3查询部门问题解决天数排行图表列表-M3接收入参字段-部门ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseScene(),"D3查询部门问题解决天数排行图表列表-M3接收入参字段-虚拟组织使用场景不能为空",false);
Assert.isNull(receptionServiceReq.getOwnTableTypeCode(),"D3查询部门问题解决天数排行图表列表-M3接收入参字段-归属内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getQuestionStatus(),"D3查询部门问题解决天数排行图表列表-M3接收入参字段-问题状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询部门问题解决天数排行图表列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
     QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
    QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto=new QueryDeptSubPersonnelSmallCircleListComReqDto();
  if(reqDto!=null){
      queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682502_1
queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682505_1
queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682503_1
    }

    /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
    Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(),"D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(),"D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getTableTypeCode(),"D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(),"D3查询部门问题解决天数排行图表列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空",false);
      queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤2: 3-7-02批量查询问题解决天数排行 - batchQueryQuestionSolvesRank
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    if(queryDeptSubPersonnelSmallCircleListComRespDto !=null){
          BatchQueryQuestionSolvesRankReq batchQueryQuestionSolvesRankReq=new BatchQueryQuestionSolvesRankReq();
  batchQueryQuestionSolvesRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682509_1
if(queryDeptSubPersonnelSmallCircleListComRespDto!= null&&  queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryQuestionSolvesRankReq.setQuestionList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682507_1
    }
if(reqDto!=null){
      batchQueryQuestionSolvesRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682508_1
batchQueryQuestionSolvesRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682510_1
    }

    /*3-7-02批量查询问题解决天数排行[9004]   */
    Assert.isNull(batchQueryQuestionSolvesRankReq.getQuestionStatus(),"D3查询部门问题解决天数排行图表列表-3-7-02批量查询问题解决天数排行-问题状态不能为空",false);
Assert.isNull(batchQueryQuestionSolvesRankReq.getSubjectLifeCycle(),"D3查询部门问题解决天数排行图表列表-3-7-02批量查询问题解决天数排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryQuestionSolvesRankReq.getSpaceId(),"D3查询部门问题解决天数排行图表列表-3-7-02批量查询问题解决天数排行-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.batchQueryQuestionSolvesRank(batchQueryQuestionSolvesRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;
           }

QueryDeptQuestionSolvesRankingChartListRespDto retData = new QueryDeptQuestionSolvesRankingChartListRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682559_1




return retData;
  }
/**
   * D3查询部门问题超时排行列表[9014]
   * gen by moon at 4/2/2024, 6:22:00 PM
   */
  @Trace(operationName = "D3查询部门问题超时排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryDeptQuestionOvertimeRankingListRespDto queryDeptQuestionOvertimeRankingList(QueryDeptQuestionOvertimeRankingListReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682572_1
receptionServiceReq.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682586_1
receptionServiceReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685281_1
receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682574_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682573_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDeptId(),"D3查询部门问题超时排行列表-M3接收入参字段-部门ID不能为空",false);
Assert.isNull(receptionServiceReq.getUseScene(),"D3查询部门问题超时排行列表-M3接收入参字段-虚拟组织使用场景不能为空",false);
Assert.isNull(receptionServiceReq.getTableTypeCode(),"D3查询部门问题超时排行列表-M3接收入参字段-冗余内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getQuestionStatus(),"D3查询部门问题超时排行列表-M3接收入参字段-问题状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询部门问题超时排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询部门下人员工作小圈子列表(公共) - queryDeptSubPersonnelSmallCircleListCom
     QueryDeptSubPersonnelSmallCircleListComRespDto queryDeptSubPersonnelSmallCircleListComRespDto = null;
    QueryDeptSubPersonnelSmallCircleListComReqDto queryDeptSubPersonnelSmallCircleListComReqDto=new QueryDeptSubPersonnelSmallCircleListComReqDto();
  if(reqDto!=null){
      queryDeptSubPersonnelSmallCircleListComReqDto.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:1682575_1
queryDeptSubPersonnelSmallCircleListComReqDto.setUseScene(reqDto.getUseScene());//SimpleFieldAssign//sourceId:1682578_1
queryDeptSubPersonnelSmallCircleListComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1685211_1
queryDeptSubPersonnelSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682576_1
    }

    /*D3查询部门下人员工作小圈子列表(公共)[8991]   */
    Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getDeptId(),"D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-部门ID不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getUseScene(),"D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getTableTypeCode(),"D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(queryDeptSubPersonnelSmallCircleListComReqDto.getSpaceId(),"D3查询部门问题超时排行列表-D3查询部门下人员工作小圈子列表(公共)-创建于空间ID不能为空",false);
      queryDeptSubPersonnelSmallCircleListComRespDto = queryDeptSubPersonnelSmallCircleListCom(queryDeptSubPersonnelSmallCircleListComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤2: 3-7-02批量查询问题超时排行 - batchQueryQuestionTimeoutRank
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    if(queryDeptSubPersonnelSmallCircleListComRespDto !=null){
          BatchQueryQuestionTimeoutRankReq batchQueryQuestionTimeoutRankReq=new BatchQueryQuestionTimeoutRankReq();
  batchQueryQuestionTimeoutRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682582_1
if(queryDeptSubPersonnelSmallCircleListComRespDto!= null&&  queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryQuestionTimeoutRankReq.setQuestionList(queryDeptSubPersonnelSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682580_1
    }
if(reqDto!=null){
      batchQueryQuestionTimeoutRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682581_1
batchQueryQuestionTimeoutRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682583_1
    }

    /*3-7-02批量查询问题超时排行[9006]   */
    Assert.isNull(batchQueryQuestionTimeoutRankReq.getQuestionStatus(),"D3查询部门问题超时排行列表-3-7-02批量查询问题超时排行-问题状态不能为空",false);
Assert.isNull(batchQueryQuestionTimeoutRankReq.getSubjectLifeCycle(),"D3查询部门问题超时排行列表-3-7-02批量查询问题超时排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryQuestionTimeoutRankReq.getSpaceId(),"D3查询部门问题超时排行列表-3-7-02批量查询问题超时排行-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.batchQueryQuestionTimeoutRank(batchQueryQuestionTimeoutRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;
           }

QueryDeptQuestionOvertimeRankingListRespDto retData = new QueryDeptQuestionOvertimeRankingListRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682593_1




return retData;
  }
/**
   * D3查询下属工作任务进度排行列表[9021]
   * gen by moon at 4/1/2024, 1:58:41 AM
   */
  @Trace(operationName = "D3查询下属工作任务进度排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySubordinateWorkTaskProgressRankListRespDto querySubordinateWorkTaskProgressRankList(QuerySubordinateWorkTaskProgressRankListReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1682125_1
queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1682120_1
queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1682122_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682123_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1682117_1
queryIdentitySmallCircleListComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1682119_1
queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682129_1
    }

    /*D3查入参身份人员作为主管的工作任务列表[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getRoleCode(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-角色标识不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-虚拟组织使用场景不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-是否外部展示不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询下属工作任务进度排行列表-D3查入参身份人员作为主管的工作任务列表-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤1: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq=new BatchQueryTaskProgressRankReq();
  batchQueryTaskProgressRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682148_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryTaskProgressRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682151_1
    }
if(reqDto!=null){
      batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1682147_1
batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682149_1
    }

    /*3-7-01批量查询任务进度排行[8999]   */
    Assert.isNull(batchQueryTaskProgressRankReq.getTaskStatus(),"D3查询下属工作任务进度排行列表-3-7-01批量查询任务进度排行-任务进展状态不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(),"D3查询下属工作任务进度排行列表-3-7-01批量查询任务进度排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(),"D3查询下属工作任务进度排行列表-3-7-01批量查询任务进度排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }

QuerySubordinateWorkTaskProgressRankListRespDto retData = new QuerySubordinateWorkTaskProgressRankListRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682156_1




return retData;
  }
/**
   * D3查询下属工作任务逾期排行列表[9022]
   * gen by moon at 4/1/2024, 1:58:54 AM
   */
  @Trace(operationName = "D3查询下属工作任务逾期排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySubordinateWorkTaskOverdueRankListRespDto querySubordinateWorkTaskOverdueRankList(QuerySubordinateWorkTaskOverdueRankListReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1682462_1
queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1682457_1
queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1682459_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682460_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1682454_1
queryIdentitySmallCircleListComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1682456_1
queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682466_1
    }

    /*D3查入参身份人员作为主管的工作任务列表[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getRoleCode(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-角色标识不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-虚拟组织使用场景不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-是否外部展示不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询下属工作任务逾期排行列表-D3查入参身份人员作为主管的工作任务列表-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤1: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq=new BatchQueryTaskExpiedRankReq();
  batchQueryTaskExpiedRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682486_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryTaskExpiedRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682483_1
    }
if(reqDto!=null){
      batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1682485_1
batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682487_1
    }

    /*3-7-01批量查询任务逾期排行[9002]   */
    Assert.isNull(batchQueryTaskExpiedRankReq.getStateCode(),"D3查询下属工作任务逾期排行列表-3-7-01批量查询任务逾期排行-内容冗余状态不能为空",false);
Assert.isNull(batchQueryTaskExpiedRankReq.getSubjectLifeCycle(),"D3查询下属工作任务逾期排行列表-3-7-01批量查询任务逾期排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(),"D3查询下属工作任务逾期排行列表-3-7-01批量查询任务逾期排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }

QuerySubordinateWorkTaskOverdueRankListRespDto retData = new QuerySubordinateWorkTaskOverdueRankListRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1682491_1




return retData;
  }
/**
   * D3查询主管下属问题解决天数排行列表[9023]
   * gen by moon at 4/1/2024, 2:32:12 AM
   */
  @Trace(operationName = "D3查询主管下属问题解决天数排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryChargeSubQuestionSolveRankListRespDto queryChargeSubQuestionSolveRankList(QueryChargeSubQuestionSolveRankListReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1683037_1
receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1683039_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683038_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDirectorInductionRecordId(),"D3查询主管下属问题解决天数排行列表-M3接收入参字段-可选主管就职记录ID不能为空",false);
Assert.isNull(receptionServiceReq.getQuestionStatus(),"D3查询主管下属问题解决天数排行列表-M3接收入参字段-问题状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询主管下属问题解决天数排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询主管我下属小圈子列表(公共) - queryChargeSubordinateSmallCircleListCom
     QueryChargeSubordinateSmallCircleListComRespDto queryChargeSubordinateSmallCircleListComRespDto = null;
    QueryChargeSubordinateSmallCircleListComReqDto queryChargeSubordinateSmallCircleListComReqDto=new QueryChargeSubordinateSmallCircleListComReqDto();
  queryChargeSubordinateSmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1682813_1
queryChargeSubordinateSmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1682814_1
queryChargeSubordinateSmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1682815_1
if(reqDto!=null){
      queryChargeSubordinateSmallCircleListComReqDto.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1682812_1
queryChargeSubordinateSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682817_1
    }

    /*D3查询主管我下属小圈子列表(公共)[9034]   */
    Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getDirectorInductionRecordId(),"D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-可选主管就职记录ID不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getUseScene(),"D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getIsPersonCharge(),"D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-是否负责人不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getTableTypeCode(),"D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getSpaceId(),"D3查询主管下属问题解决天数排行列表-D3查询主管我下属小圈子列表(公共)-创建于空间ID不能为空",false);
      queryChargeSubordinateSmallCircleListComRespDto = smallCircleCommonService.queryChargeSubordinateSmallCircleListCom(queryChargeSubordinateSmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-7-02批量查询问题解决天数排行 - batchQueryQuestionSolvesRank
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    if(queryChargeSubordinateSmallCircleListComRespDto !=null){
          BatchQueryQuestionSolvesRankReq batchQueryQuestionSolvesRankReq=new BatchQueryQuestionSolvesRankReq();
  batchQueryQuestionSolvesRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1682821_1
if(queryChargeSubordinateSmallCircleListComRespDto!= null&&  queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryQuestionSolvesRankReq.setQuestionList(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1682819_1
    }
if(reqDto!=null){
      batchQueryQuestionSolvesRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1682820_1
batchQueryQuestionSolvesRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1682822_1
    }

    /*3-7-02批量查询问题解决天数排行[9004]   */
    Assert.isNull(batchQueryQuestionSolvesRankReq.getQuestionStatus(),"D3查询主管下属问题解决天数排行列表-3-7-02批量查询问题解决天数排行-问题状态不能为空",false);
Assert.isNull(batchQueryQuestionSolvesRankReq.getSubjectLifeCycle(),"D3查询主管下属问题解决天数排行列表-3-7-02批量查询问题解决天数排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryQuestionSolvesRankReq.getSpaceId(),"D3查询主管下属问题解决天数排行列表-3-7-02批量查询问题解决天数排行-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.batchQueryQuestionSolvesRank(batchQueryQuestionSolvesRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;
           }

QueryChargeSubQuestionSolveRankListRespDto retData = new QueryChargeSubQuestionSolveRankListRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1683046_1




return retData;
  }
/**
   * D3批量查询工作任务(公共)[8982]
   * gen by moon at 4/1/2024, 2:00:18 AM
   */
  @Trace(operationName = "D3批量查询工作任务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryWorkTaskDataComRespDto batchQueryWorkTaskDataCom(BatchQueryWorkTaskDataComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-7-01批量查任务列表 - batchQueryTask
     List<OmsTask> listOmsTask =new ArrayList<>();
    BatchQueryTaskReq batchQueryTaskReq=new BatchQueryTaskReq();
  if(reqDto!=null){
      batchQueryTaskReq.setReportingTaskList(reqDto.getWorkTaskList());//list-field-assign//sourceId:1678086_1
batchQueryTaskReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1678102_1
batchQueryTaskReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1678088_1
batchQueryTaskReq.setBizSceneCode(reqDto.getBizSceneCode());//SimpleFieldAssign//sourceId:1678098_1
batchQueryTaskReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1678095_1
batchQueryTaskReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1678101_1
batchQueryTaskReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1678099_1
    }

    /*3-7-01批量查任务列表[2566]   */
    Assert.isNull(batchQueryTaskReq.getSpaceId(),"D3批量查询工作任务(公共)-3-7-01批量查任务列表-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTask(batchQueryTaskReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

BatchQueryWorkTaskDataComRespDto retData = new BatchQueryWorkTaskDataComRespDto();
  retData.setWorkContentList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, WorkContentDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1678113_1




return retData;
  }
/**
   * D3查询工作任务周期导航列表[8992]
   * gen by moon at 4/1/2024, 2:00:59 AM
   */
  @Trace(operationName = "D3查询工作任务周期导航列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryWorkTaskCycleNavListRespDto queryWorkTaskCycleNavList(QueryWorkTaskCycleNavListReqDto reqDto){


      ImplementEightReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3获取系统当前时间  65812
      //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1680078_1_65812
if(reqDto!=null){
      receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679602_1_65812
    }

    /*M3获取系统当前时间[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询工作任务周期导航列表-M3获取系统当前时间-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getComTimeField(),"D3查询工作任务周期导航列表-M3获取系统当前时间-通用时间字段不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);



//virtualUsage D2查询工作任务周期配置(公共)  65810
      QueryWorkTaskCycleConfDetailComRespDto queryWorkTaskCycleConfDetailComRespDto = null;
    QueryWorkTaskCycleConfDetailComReqDto queryWorkTaskCycleConfDetailComReqDto=new QueryWorkTaskCycleConfDetailComReqDto();
  if(reqDto!=null){
      queryWorkTaskCycleConfDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679435_1_65810
    }

    /*D2查询工作任务周期配置(公共)[8984]   */
    Assert.isNull(queryWorkTaskCycleConfDetailComReqDto.getSpaceId(),"D3查询工作任务周期导航列表-D2查询工作任务周期配置(公共)-创建于空间ID不能为空",false);
      queryWorkTaskCycleConfDetailComRespDto = fwCompDashboardWorkTaskClient.queryWorkTaskCycleConfDetailCom(queryWorkTaskCycleConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D2工作结束时间与系统当前时间比较（用于判断是否结束）  65813
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(queryWorkTaskCycleConfDetailComRespDto !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(receptionServiceRes!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1680081_1_65813
    }
if(queryWorkTaskCycleConfDetailComRespDto!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleEndTime());//SimpleFieldAssign//sourceId:1680083_1_65813
    }

    /*D2工作结束时间与系统当前时间比较（用于判断是否结束）[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3查询工作任务周期导航列表-D2工作结束时间与系统当前时间比较（用于判断是否结束）-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3查询工作任务周期导航列表-D2工作结束时间与系统当前时间比较（用于判断是否结束）-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
        //if((D2工作结束时间与系统当前时间比较（用于判断是否结束）.时间比较结果 等于 之后（大于） or D2工作结束时间与系统当前时间比较（用于判断是否结束）.时间比较结果 等于 当前（等于）))  65814

AnalysisTenementCycleComRespDto analysisTenementCycleComRespDto = null;
    if(queryWorkTaskCycleConfDetailComRespDto !=null){
          AnalysisTenementCycleComReqDto analysisTenementCycleComReqDto=new AnalysisTenementCycleComReqDto();
  if(queryWorkTaskCycleConfDetailComRespDto!=null){
      analysisTenementCycleComReqDto.setIsTenementCycle(queryWorkTaskCycleConfDetailComRespDto.getIsTenementCycle());//SimpleFieldAssign//sourceId:1679593_1_65815
    }
if(reqDto!=null){
      analysisTenementCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679596_1_65815
    }

    /*D3分析租户周期(公共)[8903]   */
    Assert.isNull(analysisTenementCycleComReqDto.getIsTenementCycle(),"D3查询工作任务周期导航列表-D3分析租户周期(公共)-是否租户周期不能为空",false);
Assert.isNull(analysisTenementCycleComReqDto.getSpaceId(),"D3查询工作任务周期导航列表-D3分析租户周期(公共)-创建于空间ID不能为空",false);
      analysisTenementCycleComRespDto = cycleTypeService.analysisTenementCycleCom(analysisTenementCycleComReqDto)/*vcase invoke isSameApp*/;



           }
List<OmsCycle> listOmsCycle =new ArrayList<>();
    if(queryWorkTaskCycleConfDetailComRespDto !=null&&analysisTenementCycleComRespDto !=null){
          QueryCycleByEqualGreateAndLessGreateListReq queryCycleByEqualGreateAndLessGreateListReq=new QueryCycleByEqualGreateAndLessGreateListReq();
  queryCycleByEqualGreateAndLessGreateListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1680114_1_65816
if(queryWorkTaskCycleConfDetailComRespDto!=null){
      queryCycleByEqualGreateAndLessGreateListReq.setCycleStartTime(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleStartTime());//SimpleFieldAssign//sourceId:1680110_1_65816
queryCycleByEqualGreateAndLessGreateListReq.setCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1680112_1_65816
    }
if(receptionServiceRes!=null){
      queryCycleByEqualGreateAndLessGreateListReq.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1680111_1_65816
    }
if(analysisTenementCycleComRespDto!=null){
      queryCycleByEqualGreateAndLessGreateListReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1680113_1_65816
queryCycleByEqualGreateAndLessGreateListReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1680115_1_65816
    }

    /*3-4-04查询周期（开始大于等于结束小于等于）列表[8993]   */
    Assert.isNull(queryCycleByEqualGreateAndLessGreateListReq.getCycleStartTime(),"D3查询工作任务周期导航列表-3-4-04查询周期（开始大于等于结束小于等于）列表-周期开始时间不能为空",false);
Assert.isNull(queryCycleByEqualGreateAndLessGreateListReq.getCycleTypeCode(),"D3查询工作任务周期导航列表-3-4-04查询周期（开始大于等于结束小于等于）列表-周期类型标识不能为空",false);
Assert.isNull(queryCycleByEqualGreateAndLessGreateListReq.getSubjectLifeCycle(),"D3查询工作任务周期导航列表-3-4-04查询周期（开始大于等于结束小于等于）列表-主体生命周期不能为空",false);
      listOmsCycle = mOmsCycleService.queryCycleByEqualGreateAndLessGreateList(queryCycleByEqualGreateAndLessGreateListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes_2 = null;
    if(listOmsCycle !=null&& !CollectionUtil.isEmpty(listOmsCycle)&& listOmsCycle.size()>0 ){
          ImplementEightReceivingFieldReqDto receptionServiceReq_1=new ImplementEightReceivingFieldReqDto();
  if(listOmsCycle!= null&& !CollectionUtil.isEmpty(listOmsCycle)&&  listOmsCycle !=null&& !CollectionUtil.isEmpty(listOmsCycle)){
      receptionServiceReq_1.setCycleList(listOmsCycle.stream().map(item -> BeanUtil.toBean(item, CycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1680324_1_65817
    }

    /*M3接收工作任务周期导航出参[8691]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
QueryWorkTaskCycleNavListRespDto retData = new QueryWorkTaskCycleNavListRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCycleList(receptionServiceRes_3.getCycleList().stream().map(item -> BeanUtil.toBean(item, CycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1680327_1
    }




return retData;
  }
/**
   * D3查询个人工作任务进度排行列表[9000]
   * gen by moon at 4/1/2024, 2:01:12 AM
   */
  @Trace(operationName = "D3查询个人工作任务进度排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPersonalWorkTaskProgressRankListRespDto queryPersonalWorkTaskProgressRankList(QueryPersonalWorkTaskProgressRankListReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1680951_1
receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681037_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1680948_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTaskStatus(),"D3查询个人工作任务进度排行列表-M3接收入参字段-任务进展状态不能为空",false);
Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(),"D3查询个人工作任务进度排行列表-M3接收入参字段-身份人员ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询个人工作任务进度排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1680847_1
queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1680854_1
queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1680849_1
queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1680851_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1680852_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1680846_1
queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1680858_1
    }

    /*D3查入参身份人员ID负责的工作任务列表[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(),"D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-是否负责人不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(),"D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(),"D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-是否外部展示不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询个人工作任务进度排行列表-D3查入参身份人员ID负责的工作任务列表-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq=new BatchQueryTaskProgressRankReq();
  batchQueryTaskProgressRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1680943_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryTaskProgressRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1680946_1
    }
if(reqDto!=null){
      batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1680942_1
batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1680944_1
    }

    /*3-7-01批量查询任务进度排行[8999]   */
    Assert.isNull(batchQueryTaskProgressRankReq.getTaskStatus(),"D3查询个人工作任务进度排行列表-3-7-01批量查询任务进度排行-任务进展状态不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(),"D3查询个人工作任务进度排行列表-3-7-01批量查询任务进度排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(),"D3查询个人工作任务进度排行列表-3-7-01批量查询任务进度排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }

QueryPersonalWorkTaskProgressRankListRespDto retData = new QueryPersonalWorkTaskProgressRankListRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681040_1




return retData;
  }
/**
   * D3查询个人工作任务逾期排行列表[9001]
   * gen by moon at 4/1/2024, 2:01:25 AM
   */
  @Trace(operationName = "D3查询个人工作任务逾期排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPersonalWorkTaskOverdueRankListRespDto queryPersonalWorkTaskOverdueRankList(QueryPersonalWorkTaskOverdueRankListReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681060_1
receptionServiceReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1681064_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681059_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(),"D3查询个人工作任务逾期排行列表-M3接收入参字段-身份人员ID不能为空",false);
Assert.isNull(receptionServiceReq.getStateCode(),"D3查询个人工作任务逾期排行列表-M3接收入参字段-内容冗余状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询个人工作任务逾期排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询我身份所在小圈子列表(公共) - queryIdentitySmallCircleListCom
     QueryIdentitySmallCircleListComRespDto queryIdentitySmallCircleListComRespDto = null;
    QueryIdentitySmallCircleListComReqDto queryIdentitySmallCircleListComReqDto=new QueryIdentitySmallCircleListComReqDto();
  queryIdentitySmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1681070_1
queryIdentitySmallCircleListComReqDto.setTableTypeCode("OMS_TASK");//sourceId:1681077_1
queryIdentitySmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1681072_1
queryIdentitySmallCircleListComReqDto.setIsDisplay("TRUE");//sourceId:1681074_1
queryIdentitySmallCircleListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681075_1
if(reqDto!=null){
      queryIdentitySmallCircleListComReqDto.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1681069_1
queryIdentitySmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681081_1
    }

    /*D3查入参身份人员ID负责的工作任务列表[8803]   */
    Assert.isNull(queryIdentitySmallCircleListComReqDto.getOriginalRoleMemberId(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-身份人员ID不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsPersonCharge(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-是否负责人不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getTableTypeCode(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-冗余内容表类型编码不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getUseScene(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-虚拟组织使用场景不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getIsDisplay(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-是否外部展示不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSubjectLifeCycle(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-主体生命周期不能为空",false);
Assert.isNull(queryIdentitySmallCircleListComReqDto.getSpaceId(),"D3查询个人工作任务逾期排行列表-D3查入参身份人员ID负责的工作任务列表-创建于空间ID不能为空",false);
      queryIdentitySmallCircleListComRespDto = smallCircleCommonService.queryIdentitySmallCircleListCom(queryIdentitySmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    if(queryIdentitySmallCircleListComRespDto !=null){
          BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq=new BatchQueryTaskExpiedRankReq();
  batchQueryTaskExpiedRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1681090_1
if(queryIdentitySmallCircleListComRespDto!= null&&  queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryTaskExpiedRankReq.setTaskDataList(queryIdentitySmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1681087_1
    }
if(reqDto!=null){
      batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1681089_1
batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1681091_1
    }

    /*3-7-01批量查询任务逾期排行[9002]   */
    Assert.isNull(batchQueryTaskExpiedRankReq.getStateCode(),"D3查询个人工作任务逾期排行列表-3-7-01批量查询任务逾期排行-内容冗余状态不能为空",false);
Assert.isNull(batchQueryTaskExpiedRankReq.getSubjectLifeCycle(),"D3查询个人工作任务逾期排行列表-3-7-01批量查询任务逾期排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(),"D3查询个人工作任务逾期排行列表-3-7-01批量查询任务逾期排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;
           }

QueryPersonalWorkTaskOverdueRankListRespDto retData = new QueryPersonalWorkTaskOverdueRankListRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1681092_1




return retData;
  }
/**
   * D3查询主管下属问题超时排行列表[9024]
   * gen by moon at 4/1/2024, 2:01:38 AM
   */
  @Trace(operationName = "D3查询主管下属问题超时排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryChargeSubQuestionTimeoutRankListRespDto queryChargeSubQuestionTimeoutRankList(QueryChargeSubQuestionTimeoutRankListReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1683276_1
receptionServiceReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1683305_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683304_1
    }

    /*M3接收字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDirectorInductionRecordId(),"D3查询主管下属问题超时排行列表-M3接收字段-可选主管就职记录ID不能为空",false);
Assert.isNull(receptionServiceReq.getQuestionStatus(),"D3查询主管下属问题超时排行列表-M3接收字段-问题状态不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询主管下属问题超时排行列表-M3接收字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询主管我下属小圈子列表(公共) - queryChargeSubordinateSmallCircleListCom
     QueryChargeSubordinateSmallCircleListComRespDto queryChargeSubordinateSmallCircleListComRespDto = null;
    QueryChargeSubordinateSmallCircleListComReqDto queryChargeSubordinateSmallCircleListComReqDto=new QueryChargeSubordinateSmallCircleListComReqDto();
  queryChargeSubordinateSmallCircleListComReqDto.setUseScene("WORK_TASK_SCENE");//sourceId:1683116_1
queryChargeSubordinateSmallCircleListComReqDto.setIsPersonCharge("TRUE");//sourceId:1683117_1
queryChargeSubordinateSmallCircleListComReqDto.setTableTypeCode("OMS_QUESTION");//sourceId:1683118_1
if(reqDto!=null){
      queryChargeSubordinateSmallCircleListComReqDto.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:1683115_1
queryChargeSubordinateSmallCircleListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683120_1
    }

    /*D3查询主管我下属小圈子列表(公共)[9034]   */
    Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getDirectorInductionRecordId(),"D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-可选主管就职记录ID不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getUseScene(),"D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-虚拟组织使用场景不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getIsPersonCharge(),"D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-是否负责人不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getTableTypeCode(),"D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(queryChargeSubordinateSmallCircleListComReqDto.getSpaceId(),"D3查询主管下属问题超时排行列表-D3查询主管我下属小圈子列表(公共)-创建于空间ID不能为空",false);
      queryChargeSubordinateSmallCircleListComRespDto = smallCircleCommonService.queryChargeSubordinateSmallCircleListCom(queryChargeSubordinateSmallCircleListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: 3-7-02批量查询问题超时排行 - batchQueryQuestionTimeoutRank
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    if(queryChargeSubordinateSmallCircleListComRespDto !=null){
          BatchQueryQuestionTimeoutRankReq batchQueryQuestionTimeoutRankReq=new BatchQueryQuestionTimeoutRankReq();
  batchQueryQuestionTimeoutRankReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1683124_1
if(queryChargeSubordinateSmallCircleListComRespDto!= null&&  queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList() !=null&& !CollectionUtil.isEmpty(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList())){
      batchQueryQuestionTimeoutRankReq.setQuestionList(queryChargeSubordinateSmallCircleListComRespDto.getVirtualOrgMemberList().stream().map(item->item.getEntityId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1683122_1
    }
if(reqDto!=null){
      batchQueryQuestionTimeoutRankReq.setQuestionStatus(reqDto.getQuestionStatus());//SimpleFieldAssign//sourceId:1683123_1
batchQueryQuestionTimeoutRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1683125_1
    }

    /*3-7-02批量查询问题超时排行[9006]   */
    Assert.isNull(batchQueryQuestionTimeoutRankReq.getQuestionStatus(),"D3查询主管下属问题超时排行列表-3-7-02批量查询问题超时排行-问题状态不能为空",false);
Assert.isNull(batchQueryQuestionTimeoutRankReq.getSubjectLifeCycle(),"D3查询主管下属问题超时排行列表-3-7-02批量查询问题超时排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryQuestionTimeoutRankReq.getSpaceId(),"D3查询主管下属问题超时排行列表-3-7-02批量查询问题超时排行-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.batchQueryQuestionTimeoutRank(batchQueryQuestionTimeoutRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;
           }

QueryChargeSubQuestionTimeoutRankListRespDto retData = new QueryChargeSubQuestionTimeoutRankListRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1683310_1




return retData;
  }
/**
   * D3查询项目下任务进度排行列表(公共)[8962]
   * gen by moon at 4/2/2024, 6:51:24 PM
   */
  @Trace(operationName = "D3查询项目下任务进度排行列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryUnderProjectTaskProgressRankListComRespDto queryUnderProjectTaskProgressRankListCom(QueryUnderProjectTaskProgressRankListComReqDto reqDto){


      QueryTaskProgressRankListComRespDto queryTaskProgressRankListComRespDto_1 =null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687459_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687460_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTaskId(),"D3查询项目下任务进度排行列表(公共)-M3接收入参字段-任务ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询项目下任务进度排行列表(公共)-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询任务进度排行列表(公共) - queryTaskProgressRankListCom
     QueryTaskProgressRankListComRespDto queryTaskProgressRankListComRespDto = null;
    QueryTaskProgressRankListComReqDto queryTaskProgressRankListComReqDto=new QueryTaskProgressRankListComReqDto();
  queryTaskProgressRankListComReqDto.setWorkTaskType("INDEPENDENT_TASK");//sourceId:1687453_1
queryTaskProgressRankListComReqDto.setTaskStatus("ONGOING");//sourceId:1687454_1
queryTaskProgressRankListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1687456_1
if(reqDto!=null){
      queryTaskProgressRankListComReqDto.setThemeContentId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687452_1
queryTaskProgressRankListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687457_1
    }

    /*D3查询任务进度排行列表(公共)[9077]   */
    Assert.isNull(queryTaskProgressRankListComReqDto.getThemeContentId(),"D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-主题内容ID不能为空",false);
Assert.isNull(queryTaskProgressRankListComReqDto.getWorkTaskType(),"D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-工作任务类别不能为空",false);
Assert.isNull(queryTaskProgressRankListComReqDto.getTaskStatus(),"D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-任务进展状态不能为空",false);
Assert.isNull(queryTaskProgressRankListComReqDto.getSubjectLifeCycle(),"D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryTaskProgressRankListComReqDto.getSpaceId(),"D3查询项目下任务进度排行列表(公共)-D3查询任务进度排行列表(公共)-创建于空间ID不能为空",false);
      queryTaskProgressRankListComRespDto = queryTaskProgressRankListCom(queryTaskProgressRankListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryTaskProgressRankListComRespDto_1 = queryTaskProgressRankListComRespDto;

QueryUnderProjectTaskProgressRankListComRespDto retData = new QueryUnderProjectTaskProgressRankListComRespDto();
  if(queryTaskProgressRankListComRespDto_1!=null){
      retData.setTaskDataList(queryTaskProgressRankListComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687463_1
    }




return retData;
  }
/**
   * D3查询重点关注任务进度排行列表(公共)[8977]
   * gen by moon at 4/2/2024, 6:51:26 PM
   */
  @Trace(operationName = "D3查询重点关注任务进度排行列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryKeyFocusWorkTaskProgressRankListComRespDto queryKeyFocusWorkTaskProgressRankListCom(QueryKeyFocusWorkTaskProgressRankListComReqDto reqDto){


      BatchQueryTaskProgressRankComRespDto batchQueryTaskProgressRankComRespDto_1 =null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1687833_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687835_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getFocusObjectId(),"D3查询重点关注任务进度排行列表(公共)-M3接收入参字段-关注主体ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询重点关注任务进度排行列表(公共)-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询重点关注列表(公共) - queryKeyFocusListCom
     QueryKeyFocusListComRespDto queryKeyFocusListComRespDto = null;
    QueryKeyFocusListComReqDto queryKeyFocusListComReqDto=new QueryKeyFocusListComReqDto();
  queryKeyFocusListComReqDto.setKeyFocusContentTypeCode("OMS_TASK");//sourceId:1677715_1
if(reqDto!=null){
      queryKeyFocusListComReqDto.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1677701_1
queryKeyFocusListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1677717_1
    }

    /*D3查询重点关注列表(公共)[8880]   */
    Assert.isNull(queryKeyFocusListComReqDto.getFocusObjectId(),"D3查询重点关注任务进度排行列表(公共)-D3查询重点关注列表(公共)-关注主体ID不能为空",false);
Assert.isNull(queryKeyFocusListComReqDto.getKeyFocusContentTypeCode(),"D3查询重点关注任务进度排行列表(公共)-D3查询重点关注列表(公共)-重点关注内容表类型编码不能为空",false);
Assert.isNull(queryKeyFocusListComReqDto.getSpaceId(),"D3查询重点关注任务进度排行列表(公共)-D3查询重点关注列表(公共)-创建于空间ID不能为空",false);
      queryKeyFocusListComRespDto = dashboardTargetContentService.queryKeyFocusListCom(queryKeyFocusListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D3批量查询任务进度排行(公共) - batchQueryTaskProgressRankCom
     BatchQueryTaskProgressRankComRespDto batchQueryTaskProgressRankComRespDto = null;
    if(queryKeyFocusListComRespDto !=null){
          BatchQueryTaskProgressRankComReqDto batchQueryTaskProgressRankComReqDto=new BatchQueryTaskProgressRankComReqDto();
  batchQueryTaskProgressRankComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1686896_1
if(queryKeyFocusListComRespDto!= null&&  queryKeyFocusListComRespDto.getKeyFocusList() !=null&& !CollectionUtil.isEmpty(queryKeyFocusListComRespDto.getKeyFocusList())){
      batchQueryTaskProgressRankComReqDto.setTaskDataList(queryKeyFocusListComRespDto.getKeyFocusList().stream().map(item->item.getKeyFocusContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1686894_1
    }
if(reqDto!=null){
      batchQueryTaskProgressRankComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1686897_1
    }

    /*D3批量查询任务进度排行(公共)[9072]   */
    Assert.isNull(batchQueryTaskProgressRankComReqDto.getSubjectLifeCycle(),"D3查询重点关注任务进度排行列表(公共)-D3批量查询任务进度排行(公共)-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskProgressRankComReqDto.getSpaceId(),"D3查询重点关注任务进度排行列表(公共)-D3批量查询任务进度排行(公共)-创建于空间ID不能为空",false);
      batchQueryTaskProgressRankComRespDto = batchQueryTaskProgressRankCom(batchQueryTaskProgressRankComReqDto)/*vcase invoke 同服务,同domain*/;


      batchQueryTaskProgressRankComRespDto_1 = batchQueryTaskProgressRankComRespDto;
           }

QueryKeyFocusWorkTaskProgressRankListComRespDto retData = new QueryKeyFocusWorkTaskProgressRankListComRespDto();
  if(batchQueryTaskProgressRankComRespDto_1!=null){
      retData.setTaskDataList(batchQueryTaskProgressRankComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1686904_1
    }




return retData;
  }
/**
   * D3批量查询任务进度排行(公共)[9072]
   * gen by moon at 4/2/2024, 6:23:05 PM
   */
  @Trace(operationName = "D3批量查询任务进度排行(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryTaskProgressRankComRespDto batchQueryTaskProgressRankCom(BatchQueryTaskProgressRankComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-7-01批量查询任务进度排行 - batchQueryTaskProgressRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    BatchQueryTaskProgressRankReq batchQueryTaskProgressRankReq=new BatchQueryTaskProgressRankReq();
  if(reqDto!=null){
      batchQueryTaskProgressRankReq.setTaskDataList(reqDto.getTaskDataList());//list-field-assign//sourceId:1686873_1
batchQueryTaskProgressRankReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1686869_1
batchQueryTaskProgressRankReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1686870_1
batchQueryTaskProgressRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1686871_1
    }

    /*3-7-01批量查询任务进度排行[8999]   */
    Assert.isNull(batchQueryTaskProgressRankReq.getSubjectLifeCycle(),"D3批量查询任务进度排行(公共)-3-7-01批量查询任务进度排行-主体生命周期不能为空",false);
Assert.isNull(batchQueryTaskProgressRankReq.getSpaceId(),"D3批量查询任务进度排行(公共)-3-7-01批量查询任务进度排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskProgressRank(batchQueryTaskProgressRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

BatchQueryTaskProgressRankComRespDto retData = new BatchQueryTaskProgressRankComRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1686890_1




return retData;
  }
/**
   * D3查询任务逾期排行列表(公共)[9073]
   * gen by moon at 4/2/2024, 6:23:19 PM
   */
  @Trace(operationName = "D3查询任务逾期排行列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTaskExpiedRankListComRespDto queryTaskExpiedRankListCom(QueryTaskExpiedRankListComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-7-01查询任务逾期排行列表 - queryTaskExpiedRankList
     List<OmsTask> listOmsTask =new ArrayList<>();
    QueryTaskExpiedRankListReq queryTaskExpiedRankListReq=new QueryTaskExpiedRankListReq();
  if(reqDto!=null){
      queryTaskExpiedRankListReq.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1687125_1
queryTaskExpiedRankListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687126_1
queryTaskExpiedRankListReq.setBizSceneCode(reqDto.getBizSceneCode());//SimpleFieldAssign//sourceId:1687127_1
queryTaskExpiedRankListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687128_1
queryTaskExpiedRankListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687129_1
    }

    /*3-7-01查询任务逾期排行列表[9076]   */
    Assert.isNull(queryTaskExpiedRankListReq.getSubjectLifeCycle(),"D3查询任务逾期排行列表(公共)-3-7-01查询任务逾期排行列表-主体生命周期不能为空",false);
Assert.isNull(queryTaskExpiedRankListReq.getSpaceId(),"D3查询任务逾期排行列表(公共)-3-7-01查询任务逾期排行列表-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.queryTaskExpiedRankList(queryTaskExpiedRankListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

QueryTaskExpiedRankListComRespDto retData = new QueryTaskExpiedRankListComRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687135_1




return retData;
  }
/**
   * D3查询项目下逾期任务排行列表[9074]
   * gen by moon at 4/2/2024, 6:23:33 PM
   */
  @Trace(operationName = "D3查询项目下逾期任务排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryUnderProjectExpiedTaskRankListRespDto queryUnderProjectExpiedTaskRankList(QueryUnderProjectExpiedTaskRankListReqDto reqDto){


      QueryTaskExpiedRankListComRespDto queryTaskExpiedRankListComRespDto_1 =null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687110_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687111_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTaskId(),"D3查询项目下逾期任务排行列表-M3接收入参字段-任务ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询项目下逾期任务排行列表-M3接收入参字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询任务逾期排行列表(公共) - queryTaskExpiedRankListCom
     QueryTaskExpiedRankListComRespDto queryTaskExpiedRankListComRespDto = null;
    QueryTaskExpiedRankListComReqDto queryTaskExpiedRankListComReqDto=new QueryTaskExpiedRankListComReqDto();
  queryTaskExpiedRankListComReqDto.setWorkTaskType("INDEPENDENT_TASK");//sourceId:1687136_1
queryTaskExpiedRankListComReqDto.setBizSceneCode("WORK_TASK");//CUSTOM_CONVENTION//sourceId:1687138_1
queryTaskExpiedRankListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1687139_1
if(reqDto!=null){
      queryTaskExpiedRankListComReqDto.setThemeContentId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1687137_1
queryTaskExpiedRankListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687140_1
    }

    /*D3查询任务逾期排行列表(公共)[9073]   */
    Assert.isNull(queryTaskExpiedRankListComReqDto.getThemeContentId(),"D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-主题内容ID不能为空",false);
Assert.isNull(queryTaskExpiedRankListComReqDto.getWorkTaskType(),"D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-工作任务类别不能为空",false);
Assert.isNull(queryTaskExpiedRankListComReqDto.getBizSceneCode(),"D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-业务场景编码不能为空",false);
Assert.isNull(queryTaskExpiedRankListComReqDto.getSubjectLifeCycle(),"D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryTaskExpiedRankListComReqDto.getSpaceId(),"D3查询项目下逾期任务排行列表-D3查询任务逾期排行列表(公共)-创建于空间ID不能为空",false);
      queryTaskExpiedRankListComRespDto = queryTaskExpiedRankListCom(queryTaskExpiedRankListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryTaskExpiedRankListComRespDto_1 = queryTaskExpiedRankListComRespDto;

QueryUnderProjectExpiedTaskRankListRespDto retData = new QueryUnderProjectExpiedTaskRankListRespDto();
  if(queryTaskExpiedRankListComRespDto_1!=null){
      retData.setWorkTaskList(queryTaskExpiedRankListComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, WorkTaskDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687142_1
    }




return retData;
  }
/**
   * D3查询任务进度排行列表(公共)[9077]
   * gen by moon at 4/2/2024, 6:23:48 PM
   */
  @Trace(operationName = "D3查询任务进度排行列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTaskProgressRankListComRespDto queryTaskProgressRankListCom(QueryTaskProgressRankListComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-4-07查询任务进度排行列表(公共) - queryTaskProgressRankListCom
     List<OmsTask> listOmsTask =new ArrayList<>();
    QueryTaskProgressRankListComReq queryTaskProgressRankListComReq=new QueryTaskProgressRankListComReq();
  if(reqDto!=null){
      queryTaskProgressRankListComReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687427_1
queryTaskProgressRankListComReq.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1687426_1
queryTaskProgressRankListComReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1687428_1
queryTaskProgressRankListComReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1687429_1
queryTaskProgressRankListComReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687430_1
queryTaskProgressRankListComReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687431_1
    }

    /*3-4-07查询任务进度排行列表(公共)[9078]   */
    Assert.isNull(queryTaskProgressRankListComReq.getSubjectLifeCycle(),"D3查询任务进度排行列表(公共)-3-4-07查询任务进度排行列表(公共)-主体生命周期不能为空",false);
Assert.isNull(queryTaskProgressRankListComReq.getSpaceId(),"D3查询任务进度排行列表(公共)-3-4-07查询任务进度排行列表(公共)-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.queryTaskProgressRankListCom(queryTaskProgressRankListComReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

QueryTaskProgressRankListComRespDto retData = new QueryTaskProgressRankListComRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687451_1




return retData;
  }
/**
   * D3查询问题超时排行列表(公共)[9081]
   * gen by moon at 4/2/2024, 6:24:02 PM
   */
  @Trace(operationName = "D3查询问题超时排行列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryQuestionTimeoutRankListComRespDto queryQuestionTimeoutRankListCom(QueryQuestionTimeoutRankListComReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: 3-7-02查询问题超时排行列表 - queryQuestionTimeoutRankList
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    QueryQuestionTimeoutRankListReq queryQuestionTimeoutRankListReq=new QueryQuestionTimeoutRankListReq();
  if(reqDto!=null){
      queryQuestionTimeoutRankListReq.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1687502_1
queryQuestionTimeoutRankListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687499_1
queryQuestionTimeoutRankListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687500_1
queryQuestionTimeoutRankListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687501_1
    }

    /*3-7-02查询问题超时排行列表[9079]   */
    Assert.isNull(queryQuestionTimeoutRankListReq.getSubjectLifeCycle(),"D3查询问题超时排行列表(公共)-3-7-02查询问题超时排行列表-主体生命周期不能为空",false);
Assert.isNull(queryQuestionTimeoutRankListReq.getSpaceId(),"D3查询问题超时排行列表(公共)-3-7-02查询问题超时排行列表-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.queryQuestionTimeoutRankList(queryQuestionTimeoutRankListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;

QueryQuestionTimeoutRankListComRespDto retData = new QueryQuestionTimeoutRankListComRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687511_1




return retData;
  }
/**
   * D3查询问题解决天数排行列表(公共)[9082]
   * gen by moon at 4/2/2024, 6:24:16 PM
   */
  @Trace(operationName = "D3查询问题解决天数排行列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryQuestionSolvesRankListComRespDto queryQuestionSolvesRankListCom(QueryQuestionSolvesRankListComReqDto reqDto){


      List<OmsQuestion> listOmsQuestion_1 =new ArrayList<>();
//步骤0: 3-7-02查询问题解决天数排行列表 - queryQuestionSolvesRankList
     List<OmsQuestion> listOmsQuestion =new ArrayList<>();
    QueryQuestionSolvesRankListReq queryQuestionSolvesRankListReq=new QueryQuestionSolvesRankListReq();
  if(reqDto!=null){
      queryQuestionSolvesRankListReq.setParentEntityId(reqDto.getParentEntityId());//SimpleFieldAssign//sourceId:1687864_1
queryQuestionSolvesRankListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1687865_1
queryQuestionSolvesRankListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687866_1
queryQuestionSolvesRankListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687867_1
    }

    /*3-7-02查询问题解决天数排行列表[9080]   */
    Assert.isNull(queryQuestionSolvesRankListReq.getSubjectLifeCycle(),"D3查询问题解决天数排行列表(公共)-3-7-02查询问题解决天数排行列表-主体生命周期不能为空",false);
Assert.isNull(queryQuestionSolvesRankListReq.getSpaceId(),"D3查询问题解决天数排行列表(公共)-3-7-02查询问题解决天数排行列表-创建于空间ID不能为空",false);
      listOmsQuestion = mOmsQuestionService.queryQuestionSolvesRankList(queryQuestionSolvesRankListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsQuestion_1 = listOmsQuestion;

QueryQuestionSolvesRankListComRespDto retData = new QueryQuestionSolvesRankListComRespDto();
  retData.setQuestionList(listOmsQuestion_1.stream().map(item -> BeanUtil.toBean(item, QuestionDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687888_1




return retData;
  }
/**
   * D3查询重点关注任务逾期排行列表[9084]
   * gen by moon at 4/2/2024, 6:51:39 PM
   */
  @Trace(operationName = "D3查询重点关注任务逾期排行列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryKeyFocusWorkExpiedTaskRankListRespDto queryKeyFocusWorkExpiedTaskRankList(QueryKeyFocusWorkExpiedTaskRankListReqDto reqDto){


      BatchQueryTaskExpiedRankComRespDto batchQueryTaskExpiedRankComRespDto_1 =null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1687863_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687869_1
    }

    /*M3接收字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getFocusObjectId(),"D3查询重点关注任务逾期排行列表-M3接收字段-关注主体ID不能为空",false);
Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询重点关注任务逾期排行列表-M3接收字段-创建于空间ID不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);




//步骤1: D3查询重点关注列表(公共) - queryKeyFocusListCom
     QueryKeyFocusListComRespDto queryKeyFocusListComRespDto = null;
    QueryKeyFocusListComReqDto queryKeyFocusListComReqDto=new QueryKeyFocusListComReqDto();
  queryKeyFocusListComReqDto.setKeyFocusContentTypeCode("OMS_TASK");//sourceId:1687894_1
if(reqDto!=null){
      queryKeyFocusListComReqDto.setFocusObjectId(reqDto.getFocusObjectId());//SimpleFieldAssign//sourceId:1687883_1
queryKeyFocusListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687886_1
    }

    /*D3查询重点关注列表(公共)[8880]   */
    Assert.isNull(queryKeyFocusListComReqDto.getFocusObjectId(),"D3查询重点关注任务逾期排行列表-D3查询重点关注列表(公共)-关注主体ID不能为空",false);
Assert.isNull(queryKeyFocusListComReqDto.getKeyFocusContentTypeCode(),"D3查询重点关注任务逾期排行列表-D3查询重点关注列表(公共)-重点关注内容表类型编码不能为空",false);
Assert.isNull(queryKeyFocusListComReqDto.getSpaceId(),"D3查询重点关注任务逾期排行列表-D3查询重点关注列表(公共)-创建于空间ID不能为空",false);
      queryKeyFocusListComRespDto = dashboardTargetContentService.queryKeyFocusListCom(queryKeyFocusListComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D3批量查询任务逾期排行(公共) - batchQueryTaskExpiedRankCom
     BatchQueryTaskExpiedRankComRespDto batchQueryTaskExpiedRankComRespDto = null;
    if(queryKeyFocusListComRespDto !=null){
          BatchQueryTaskExpiedRankComReqDto batchQueryTaskExpiedRankComReqDto=new BatchQueryTaskExpiedRankComReqDto();
  batchQueryTaskExpiedRankComReqDto.setStateCode("OVERDUE");//sourceId:1687920_1
batchQueryTaskExpiedRankComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1687921_1
if(queryKeyFocusListComRespDto!= null&&  queryKeyFocusListComRespDto.getKeyFocusList() !=null&& !CollectionUtil.isEmpty(queryKeyFocusListComRespDto.getKeyFocusList())){
      batchQueryTaskExpiedRankComReqDto.setTaskDataList(queryKeyFocusListComRespDto.getKeyFocusList().stream().map(item->item.getKeyFocusContentId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1687919_1
    }
if(reqDto!=null){
      batchQueryTaskExpiedRankComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687922_1
    }

    /*D3批量查询任务逾期排行(公共)[9086]   */
    Assert.isNull(batchQueryTaskExpiedRankComReqDto.getSpaceId(),"D3查询重点关注任务逾期排行列表-D3批量查询任务逾期排行(公共)-创建于空间ID不能为空",false);
      batchQueryTaskExpiedRankComRespDto = batchQueryTaskExpiedRankCom(batchQueryTaskExpiedRankComReqDto)/*vcase invoke 同服务,同domain*/;


      batchQueryTaskExpiedRankComRespDto_1 = batchQueryTaskExpiedRankComRespDto;
           }

QueryKeyFocusWorkExpiedTaskRankListRespDto retData = new QueryKeyFocusWorkExpiedTaskRankListRespDto();
  if(batchQueryTaskExpiedRankComRespDto_1!=null){
      retData.setTaskDataList(batchQueryTaskExpiedRankComRespDto_1.getTaskDataList().stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687929_1
    }




return retData;
  }
/**
   * D3批量查询任务逾期排行(公共)[9086]
   * gen by moon at 4/2/2024, 6:24:43 PM
   */
  @Trace(operationName = "D3批量查询任务逾期排行(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryTaskExpiedRankComRespDto batchQueryTaskExpiedRankCom(BatchQueryTaskExpiedRankComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-7-01批量查询任务逾期排行 - batchQueryTaskExpiedRank
     List<OmsTask> listOmsTask =new ArrayList<>();
    BatchQueryTaskExpiedRankReq batchQueryTaskExpiedRankReq=new BatchQueryTaskExpiedRankReq();
  if(reqDto!=null){
      batchQueryTaskExpiedRankReq.setTaskDataList(reqDto.getTaskDataList());//list-field-assign//sourceId:1687909_1
batchQueryTaskExpiedRankReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1687911_1
batchQueryTaskExpiedRankReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1687912_1
batchQueryTaskExpiedRankReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1687913_1
    }

    /*3-7-01批量查询任务逾期排行[9002]   */
    Assert.isNull(batchQueryTaskExpiedRankReq.getSpaceId(),"D3批量查询任务逾期排行(公共)-3-7-01批量查询任务逾期排行-创建于空间ID不能为空",false);
      listOmsTask = mOmsTaskService.batchQueryTaskExpiedRank(batchQueryTaskExpiedRankReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

BatchQueryTaskExpiedRankComRespDto retData = new BatchQueryTaskExpiedRankComRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1687918_1




return retData;
  }
/**
   * D3查询其他大屏周期名称详情(公共)[8992]
   * gen by moon at 6/16/2024, 8:23:05 PM
   */
  @Trace(operationName = "D3查询其他大屏周期名称详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryOtherDashboardCycleNameDetailComRespDto queryOtherDashboardCycleNameDetailCom(QueryOtherDashboardCycleNameDetailComReqDto reqDto){


      QueryWorkTaskCycleConfDetailComRespDto queryWorkTaskCycleConfDetailComRespDto_1 =null;
ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3获取系统当前时间  65812
      //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1680078_1_65812
if(reqDto!=null){
      receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679602_1_65812
    }

    /*M3获取系统当前时间[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-M3获取系统当前时间-创建于空间ID不能为空",false);
Assert.isNull(receptionServiceReq.getComTimeField(),"D3查询其他大屏周期名称详情(公共)-M3获取系统当前时间-通用时间字段不能为空",false);
      receptionServiceRes = nbDashboardWorkTask.implementEightReceivingField(receptionServiceReq);



//virtualUsage D2查询工作任务周期配置(公共)  65810
      QueryWorkTaskCycleConfDetailComRespDto queryWorkTaskCycleConfDetailComRespDto = null;
    QueryWorkTaskCycleConfDetailComReqDto queryWorkTaskCycleConfDetailComReqDto=new QueryWorkTaskCycleConfDetailComReqDto();
  if(reqDto!=null){
      queryWorkTaskCycleConfDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679435_1_65810
    }

    /*D2查询工作任务周期配置(公共)[8984]   */
    Assert.isNull(queryWorkTaskCycleConfDetailComReqDto.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-D2查询工作任务周期配置(公共)-创建于空间ID不能为空",false);
      queryWorkTaskCycleConfDetailComRespDto = fwCompDashboardWorkTaskClient.queryWorkTaskCycleConfDetailCom(queryWorkTaskCycleConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryWorkTaskCycleConfDetailComRespDto_1 = queryWorkTaskCycleConfDetailComRespDto;
//virtualUsage D3分析租户周期(公共)  70002
      AnalysisTenementCycleComRespDto analysisTenementCycleComRespDto = null;
    if(queryWorkTaskCycleConfDetailComRespDto !=null){
          AnalysisTenementCycleComReqDto analysisTenementCycleComReqDto=new AnalysisTenementCycleComReqDto();
  if(queryWorkTaskCycleConfDetailComRespDto!=null){
      analysisTenementCycleComReqDto.setIsTenementCycle(queryWorkTaskCycleConfDetailComRespDto.getIsTenementCycle());//SimpleFieldAssign//sourceId:1679593_1_70002
    }
if(reqDto!=null){
      analysisTenementCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1679596_1_70002
    }

    /*D3分析租户周期(公共)[8903]   */
    Assert.isNull(analysisTenementCycleComReqDto.getIsTenementCycle(),"D3查询其他大屏周期名称详情(公共)-D3分析租户周期(公共)-是否租户周期不能为空",false);
Assert.isNull(analysisTenementCycleComReqDto.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-D3分析租户周期(公共)-创建于空间ID不能为空",false);
      analysisTenementCycleComRespDto = cycleTypeService.analysisTenementCycleCom(analysisTenementCycleComReqDto)/*vcase invoke isSameApp*/;



           }
if((reqDto!= null&& reqDto.getCycleStartTime() == null &&reqDto!= null&& reqDto.getCycleEndTime() == null )) {
        //if((D3查询其他大屏周期名称详情(公共).周期开始时间 值等于空  and D3查询其他大屏周期名称详情(公共).周期结束时间 值等于空 ))  70099

      OmsCycle omsCycle = null;
    if(queryWorkTaskCycleConfDetailComRespDto !=null&&analysisTenementCycleComRespDto !=null){
          QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq=new QueryTimeRangeFindCycleDetailReq();
  queryTimeRangeFindCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1866382_1_70101
if(receptionServiceRes!=null){
      queryTimeRangeFindCycleDetailReq.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1866378_1_70101
queryTimeRangeFindCycleDetailReq.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1866379_1_70101
    }
if(queryWorkTaskCycleConfDetailComRespDto!=null){
      queryTimeRangeFindCycleDetailReq.setCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1866380_1_70101
    }
if(analysisTenementCycleComRespDto!=null){
      queryTimeRangeFindCycleDetailReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1866381_1_70101
queryTimeRangeFindCycleDetailReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1866390_1_70101
    }

    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getSubjectLifeCycle(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-主体生命周期不能为空",false);
//Assert.isNull(queryTimeRangeFindCycleDetailReq.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-创建于空间ID不能为空",false);
      omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsCycle== null||  omsCycle.getCycleId() ==null,"找不到数据，系统异常",false);


           }
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsCycle !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(omsCycle!=null){
      receptionServiceReq_1.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1873445_1_70103
receptionServiceReq_1.setCycleStandardName(omsCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:1873447_1_70103
    }

    /*M3接收周期ID出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleId(),"D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getCycleStandardName(),"D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期名称不能为空",false);
      receptionServiceRes_2 = nbDashboardWorkTask.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((reqDto!= null&& reqDto.getCycleStartTime() != null &&reqDto!= null&& reqDto.getCycleEndTime() != null )){
       //elseif((D3查询其他大屏周期名称详情(公共).周期开始时间 值不等于空  and D3查询其他大屏周期名称详情(公共).周期结束时间 值不等于空 ))  70100

OmsCycle omsCycle_2 = null;
    if(queryWorkTaskCycleConfDetailComRespDto !=null&&analysisTenementCycleComRespDto !=null){
          QueryCycleByTimeEqualDetailReq queryCycleByTimeEqualDetailReq=new QueryCycleByTimeEqualDetailReq();
  queryCycleByTimeEqualDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1873225_1_70102
if(reqDto!=null){
      queryCycleByTimeEqualDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1873221_1_70102
queryCycleByTimeEqualDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1873222_1_70102
    }
if(queryWorkTaskCycleConfDetailComRespDto!=null){
      queryCycleByTimeEqualDetailReq.setCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto.getWorkCycleTypeCode());//SimpleFieldAssign//sourceId:1873223_1_70102
    }
if(analysisTenementCycleComRespDto!=null){
      queryCycleByTimeEqualDetailReq.setPlatformData(analysisTenementCycleComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:1873224_1_70102
queryCycleByTimeEqualDetailReq.setSpaceId(analysisTenementCycleComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:1873226_1_70102
    }

    /*3-4-04查询周期详情（起止时间等于）[9823]   */
    Assert.isNull(queryCycleByTimeEqualDetailReq.getCycleStartTime(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-周期开始时间不能为空",false);
Assert.isNull(queryCycleByTimeEqualDetailReq.getCycleEndTime(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-周期结束时间不能为空",false);
Assert.isNull(queryCycleByTimeEqualDetailReq.getCycleTypeCode(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-周期类型标识不能为空",false);
Assert.isNull(queryCycleByTimeEqualDetailReq.getPlatformData(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-是否是平台不能为空",false);
Assert.isNull(queryCycleByTimeEqualDetailReq.getSubjectLifeCycle(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-主体生命周期不能为空",false);
//Assert.isNull(queryCycleByTimeEqualDetailReq.getSpaceId(),"D3查询其他大屏周期名称详情(公共)-3-4-04查询周期详情（起止时间等于）-创建于空间ID不能为空",false);
      omsCycle_2 = mOmsCycleService.queryCycleByTimeEqualDetail(queryCycleByTimeEqualDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    if(omsCycle_2 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(omsCycle_2!=null){
      receptionServiceReq_2.setCycleId(omsCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1873445_1_70104
receptionServiceReq_2.setCycleStandardName(omsCycle_2.getCycleStandardName());//SimpleFieldAssign//sourceId:1873447_1_70104
    }

    /*M3接收周期ID出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCycleId(),"D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期ID不能为空",false);
Assert.isNull(receptionServiceReq_2.getCycleStandardName(),"D3查询其他大屏周期名称详情(公共)-M3接收周期ID出参-周期名称不能为空",false);
      receptionServiceRes_4 = nbDashboardWorkTask.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
           }
QueryOtherDashboardCycleNameDetailComRespDto retData = new QueryOtherDashboardCycleNameDetailComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1873448_1
retData.setCycleStandardName(receptionServiceRes_3.getCycleStandardName());//SimpleFieldAssign//sourceId:1873449_1
    }
if(queryWorkTaskCycleConfDetailComRespDto_1!=null){
      retData.setUpdateCycleTypeCode(queryWorkTaskCycleConfDetailComRespDto_1.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1866391_1
    }




return retData;
  }
/**
   * D3查询时间统计任务列表(公共)[10075]
   * gen by moon at 9/15/2024, 7:23:55 PM
   */
  @Trace(operationName = "D3查询时间统计任务列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTimeStatisticsTasksListComRespDto queryTimeStatisticsTasksListCom(QueryTimeStatisticsTasksListComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-7-01查询时间统计任务列表(公共) - queryTimeStatisticsTasksListCom
     List<OmsTask> listOmsTask =new ArrayList<>();
    QueryTimeStatisticsTasksListComReq queryTimeStatisticsTasksListComReq=new QueryTimeStatisticsTasksListComReq();
  if(reqDto!=null){
      queryTimeStatisticsTasksListComReq.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1960843_1
queryTimeStatisticsTasksListComReq.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1960844_1
queryTimeStatisticsTasksListComReq.setCoordObjectId(reqDto.getCoordObjectId());//SimpleFieldAssign//sourceId:1960835_1
queryTimeStatisticsTasksListComReq.setTaskType(reqDto.getTaskType());//SimpleFieldAssign//sourceId:1960833_1
queryTimeStatisticsTasksListComReq.setWorkTaskType(reqDto.getWorkTaskType());//SimpleFieldAssign//sourceId:1960834_1
queryTimeStatisticsTasksListComReq.setBizSceneCode(reqDto.getBizSceneCode());//SimpleFieldAssign//sourceId:1960836_1
queryTimeStatisticsTasksListComReq.setIsAlignment(reqDto.getIsAlignment());//SimpleFieldAssign//sourceId:1960837_1
queryTimeStatisticsTasksListComReq.setObjectiveId(reqDto.getObjectiveId());//SimpleFieldAssign//sourceId:2002267_1
queryTimeStatisticsTasksListComReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1960838_1
queryTimeStatisticsTasksListComReq.setIsOverdue(reqDto.getIsOverdue());//SimpleFieldAssign//sourceId:1988850_1
queryTimeStatisticsTasksListComReq.setIsComplete(reqDto.getIsComplete());//SimpleFieldAssign//sourceId:1960839_1
queryTimeStatisticsTasksListComReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1960840_1
queryTimeStatisticsTasksListComReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1960873_1
queryTimeStatisticsTasksListComReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1960841_1
queryTimeStatisticsTasksListComReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2002268_1
queryTimeStatisticsTasksListComReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1960842_1
    }

    /*3-7-01查询时间统计任务列表(公共)[10074]   */

      listOmsTask = mOmsTaskService.queryTimeStatisticsTasksListCom(queryTimeStatisticsTasksListComReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

QueryTimeStatisticsTasksListComRespDto retData = new QueryTimeStatisticsTasksListComRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1960858_1




return retData;
  }
/**
   * D3批量查询时间统计任务(公共)[10077]
   * gen by moon at 8/8/2024, 9:55:08 AM
   */
  @Trace(operationName = "D3批量查询时间统计任务(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchQueryTimeStatisticsTasksComRespDto batchQueryTimeStatisticsTasksCom(BatchQueryTimeStatisticsTasksComReqDto reqDto){


      List<OmsTask> listOmsTask_1 =new ArrayList<>();
//步骤0: 3-7-09批量查询时间统计任务 - batchQueryTimeStatisticsTasks
     List<OmsTask> listOmsTask =new ArrayList<>();
    BatchQueryTimeStatisticsTasksReq batchQueryTimeStatisticsTasksReq=new BatchQueryTimeStatisticsTasksReq();
  if(reqDto!=null){
      batchQueryTimeStatisticsTasksReq.setTaskDataList(reqDto.getTaskDataList());//list-field-assign//sourceId:1960900_1
batchQueryTimeStatisticsTasksReq.setTaskType(reqDto.getTaskType());//SimpleFieldAssign//sourceId:1960901_1
batchQueryTimeStatisticsTasksReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1960902_1
batchQueryTimeStatisticsTasksReq.setIsAlignment(reqDto.getIsAlignment());//SimpleFieldAssign//sourceId:1960903_1
batchQueryTimeStatisticsTasksReq.setPlanStartTime(reqDto.getPlanStartTime());//SimpleFieldAssign//sourceId:1960904_1
batchQueryTimeStatisticsTasksReq.setPlanEndTime(reqDto.getPlanEndTime());//SimpleFieldAssign//sourceId:1960905_1
batchQueryTimeStatisticsTasksReq.setTaskStatus(reqDto.getTaskStatus());//SimpleFieldAssign//sourceId:1960906_1
batchQueryTimeStatisticsTasksReq.setStateCode(reqDto.getStateCode());//SimpleFieldAssign//sourceId:1960907_1
batchQueryTimeStatisticsTasksReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1960908_1
batchQueryTimeStatisticsTasksReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1960909_1
    }

    /*3-7-09批量查询时间统计任务[10076]   */

      listOmsTask = mOmsTaskService.batchQueryTimeStatisticsTasks(batchQueryTimeStatisticsTasksReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsTask_1 = listOmsTask;

BatchQueryTimeStatisticsTasksComRespDto retData = new BatchQueryTimeStatisticsTasksComRespDto();
  retData.setTaskDataList(listOmsTask_1.stream().map(item -> BeanUtil.toBean(item, TaskDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1960921_1




return retData;
  }
  //
}
